// 基础URL
const API_BASE_URL = 'http://localhost:8080/api/goods';

// 创建Vue应用
const app = Vue.createApp({
    data() {
        return {
            // 商品列表数据
            goodsList: [],
            // 分页相关
            pagination: {
                currentPage: 1,
                itemsPerPage: 5,
                totalPages: 1
            },
            // 商品总数
            totalGoods: 0,
            // 加载状态
            loading: false,
            // 是否处于编辑模式
            editMode: false,
            // 表单数据
            form: {
                id: '',
                name: '',
                description: '',
                price: ''
            },
            // 查询表单
            queryForm: {
                id: ''
            },
            // 查询结果
            queryResult: null,
            // 交易信息
            transactionInfo: {
                transactionHash: '',
                blockNumber: '',
                status: '',
                from: '',
                to: ''
            },
            // 弹窗实例
            transactionModal: null,
            // 表单标题
            formTitle: '创建商品',
            // 提交按钮文本
            submitButtonText: '创建',
            // 是否为更新操作
            isUpdate: false
        }
    },
    
    computed: {
        // 分页后的商品列表
        paginatedGoodsList() {
            const start = (this.pagination.currentPage - 1) * this.pagination.itemsPerPage;
            const end = start + this.pagination.itemsPerPage;
            return this.goodsList.slice(start, end);
        },
        
        // 计算总页数
        totalPages() {
            return Math.ceil(this.goodsList.length / this.pagination.itemsPerPage);
        },
        
        // 页码数组，用于分页导航
        pageNumbers() {
            const pages = [];
            const maxVisiblePages = 5; // 最多显示的页码数量
            
            if (this.totalPages <= maxVisiblePages) {
                // 如果总页数少于最大显示页码数，显示所有页码
                for (let i = 1; i <= this.totalPages; i++) {
                    pages.push(i);
                }
            } else {
                // 否则，显示当前页附近的页码
                let startPage = Math.max(1, this.pagination.currentPage - Math.floor(maxVisiblePages / 2));
                let endPage = startPage + maxVisiblePages - 1;
                
                if (endPage > this.totalPages) {
                    endPage = this.totalPages;
                    startPage = Math.max(1, endPage - maxVisiblePages + 1);
                }
                
                for (let i = startPage; i <= endPage; i++) {
                    pages.push(i);
                }
            }
            
            return pages;
        }
    },
    
    mounted() {
        // 初始化弹窗
        this.transactionModal = new bootstrap.Modal(document.getElementById('transactionModal'));
        
        // 加载所有商品
        this.loadAllGoods();
    },
    
    methods: {
        // 切换页码
        changePage(page) {
            if (page < 1 || page > this.totalPages) return;
            this.pagination.currentPage = page;
            
            // 滚动到商品列表顶部
            const goodsListElement = document.querySelector('.goods-table');
            if (goodsListElement) {
                goodsListElement.scrollIntoView({ behavior: 'smooth' });
            }
        },
        
        // 查询商品
        async queryGoods() {
            if (!this.queryForm.id) {
                alert('请输入要查询的商品ID');
                return;
            }
            
            this.loading = true;
            this.queryResult = null;
            
            try {
                const id = parseInt(this.queryForm.id, 10);
                if (isNaN(id) || id <= 0) {
                    alert('请输入有效的商品ID（正整数）');
                    this.loading = false;
                    return;
                }
                
                console.log(`开始查询商品ID=${id}...`);
                const response = await axios.get(`${API_BASE_URL}/contract/${id}`);
                console.log(`查询响应:`, response);
                
                if (response.data.code === '0' && response.data.data) {
                    this.queryResult = response.data.data;
                    
                    // 处理原始数据
                    const rawData = this.queryResult.rawData;
                    if (rawData) {
                        // 如果原始数据是字符串类型
                        if (typeof rawData === 'string') {
                            console.log('原始数据是字符串:', rawData);
                            
                            // 提取JSON数据
                            let jsonStr = rawData;
                            if (jsonStr.startsWith('"') && jsonStr.endsWith('"')) {
                                jsonStr = jsonStr.substring(1, jsonStr.length - 1);
                            }
                            jsonStr = jsonStr.replace(/\\"/g, '"');
                            
                            try {
                                // 尝试解析JSON
                                const parsedData = JSON.parse(jsonStr);
                                if (Array.isArray(parsedData) && parsedData.length >= 3) {
                                    this.queryResult.contractData = {
                                        name: String(parsedData[0]),
                                        description: String(parsedData[1]),
                                        price: String(parsedData[2])
                                    };
                                    console.log('JSON解析成功:', this.queryResult.contractData);
                                }
                            } catch (e) {
                                console.error('JSON解析失败，使用简单分割方法');
                                
                                // 去掉最外层的引号和方括号
                                let content = jsonStr.replace(/^\[|\]$/g, '');
                                // 简单分割
                                let parts = content.split(',');
                                
                                if (parts.length >= 3) {
                                    // 清理每个部分的引号
                                    const name = parts[0].replace(/^"|"$|^'|'$/g, '');
                                    const description = parts[1].replace(/^"|"$|^'|'$/g, '');
                                    const price = parts[2].replace(/[^\d.]/g, '');
                                    
                                    this.queryResult.contractData = {
                                        name: name,
                                        description: description,
                                        price: price
                                    };
                                    console.log('简单分割结果:', this.queryResult.contractData);
                                }
                            }
                        } else if (Array.isArray(rawData)) {
                            // 如果原始数据直接是数组
                            console.log('原始数据是数组:', rawData);
                            if (rawData.length >= 3) {
                                this.queryResult.contractData = {
                                    name: String(rawData[0]),
                                    description: String(rawData[1]),
                                    price: String(rawData[2])
                                };
                            }
                        }
                    }
                    
                    // 如果没有成功创建contractData
                    if (!this.queryResult.contractData) {
                        console.warn('无法从返回数据创建商品信息对象');
                        this.queryResult.contractData = {
                            name: '数据解析失败',
                            description: '请检查浏览器控制台',
                            price: '0'
                        };
                    }
                } else {
                    // 查询失败
                    let message = response.data.message || '未知错误';
                    console.error(`查询失败: ${message}`);
                    this.queryResult = { 
                        id: id, 
                        contractData: null,
                        error: message
                    };
                }
            } catch (error) {
                console.error('查询失败:', error);
                this.queryResult = { 
                    id: this.queryForm.id, 
                    contractData: null,
                    error: error.message || '查询请求失败'
                };
            } finally {
                this.loading = false;
            }
        },
        
        // 加载查询结果到表单
        loadProductToForm(queryResult) {
            if (!queryResult || !queryResult.contractData) return;
            
            this.editMode = true;
            this.form.id = queryResult.id;
            this.form.name = queryResult.contractData.name;
            this.form.description = queryResult.contractData.description;
            this.form.price = queryResult.contractData.price;
            
            // 滚动到表单顶部
            window.scrollTo({ top: 0, behavior: 'smooth' });
        },
        
        // 加载所有商品ID并获取详细信息
        async loadAllGoods() {
            this.loading = true;
            try {
                // 先获取所有商品ID
                console.log("开始获取商品ID列表...");
                const response = await axios.get(`${API_BASE_URL}/list`);
                console.log("商品ID列表API响应:", response);
                
                if (response.data.code === '0' && response.data.data) {
                    // 响应数据现在直接是商品ID列表
                    const goodsIdsData = response.data.data;
                    console.log("原始商品ID数据:", goodsIdsData);
                    let goodsIds = [];
                    
                    // 尝试解析响应数据
                    try {
                        if (typeof goodsIdsData === 'string') {
                            // 如果是JSON字符串，尝试解析
                            console.log("尝试解析JSON字符串:", goodsIdsData);
                            goodsIds = JSON.parse(goodsIdsData);
                        } else if (Array.isArray(goodsIdsData)) {
                            // 如果已经是数组，直接使用
                            console.log("获取到商品ID数组:", goodsIdsData);
                            goodsIds = goodsIdsData;
                        } else {
                            console.warn('商品ID数据格式不符合预期:', goodsIdsData);
                            
                            // 尝试将任何类型的数据转换为数组
                            if (goodsIdsData !== null && goodsIdsData !== undefined) {
                                try {
                                    const strValue = String(goodsIdsData);
                                    console.log("尝试从字符串解析商品ID:", strValue);
                                    
                                    // 尝试移除可能的括号和引号
                                    const cleanStr = strValue.replace(/^\[|\]$|\"|\'/g, '');
                                    const parts = cleanStr.split(',').map(p => p.trim()).filter(p => p !== '');
                                    
                                    if (parts.length > 0) {
                                        goodsIds = parts.map(p => parseInt(p, 10)).filter(id => !isNaN(id));
                                        console.log("从字符串提取的商品ID:", goodsIds);
                                    } else {
                                        goodsIds = [];
                                    }
                                } catch (e) {
                                    console.error("从非数组格式提取ID失败:", e);
                                    goodsIds = [];
                                }
                            } else {
                                goodsIds = [];
                            }
                        }
                    } catch (parseError) {
                        console.error('解析商品ID列表失败:', parseError);
                        goodsIds = [];
                    }
                    
                    console.log("最终解析出的商品ID列表:", goodsIds);
                    
                    // 清空当前商品列表
                    this.goodsList = [];
                    
                    // 逐个获取商品详情
                    for (const id of goodsIds) {
                        console.log(`开始获取商品ID ${id} 的详情...`);
                        await this.loadGoodsDetail(id);
                    }
                    
                    console.log("所有商品加载完成，总数:", this.goodsList.length);
                    
                    // 更新总数
                    this.totalGoods = this.goodsList.length;
                }
            } catch (error) {
                console.error('加载商品列表失败:', error);
                alert('加载商品列表失败，请查看控制台了解详情');
            } finally {
                this.loading = false;
            }
        },
        
        // 递归清理嵌套的方括号和引号
        cleanNestedBracketsAndQuotes(input) {
            if (typeof input !== 'string') return input;
            
            // 如果输入是空字符串，直接返回
            if (!input.trim()) return '';
            
            try {
                // 先尝试解析JSON
                const parsed = JSON.parse(input);
                
                // 如果解析成功且是数组，递归处理每个元素
                if (Array.isArray(parsed)) {
                    if (parsed.length === 0) return '';
                    
                    // 如果是单值数组且为字符串类型，递归处理
                    if (parsed.length === 1 && typeof parsed[0] === 'string') {
                        return this.cleanNestedBracketsAndQuotes(parsed[0]);
                    }
                    
                    // 处理多值数组
                    return parsed.map(item => this.cleanNestedBracketsAndQuotes(item));
                }
                
                // 如果成功解析为字符串或其他类型，直接返回
                if (typeof parsed === 'string') {
                    // 字符串仍可能需要进一步清理
                    return this.cleanStringContent(parsed);
                }
                
                return parsed;
            } catch (e) {
                // 解析失败，说明不是有效的JSON，使用正则表达式清理
                return this.cleanStringContent(input);
            }
        },
        
        // 清理字符串内容
        cleanStringContent(str) {
            if (typeof str !== 'string') return str;
            
            // 处理多层嵌套的引号和方括号
            let result = str;
            
            // 移除开头和结尾的转义引号和普通引号
            result = result.replace(/^\\?["']|\\?["']$/g, '');
            
            // 移除开头和结尾的方括号
            result = result.replace(/^\[|\]$/g, '');
            
            // 移除多余的转义符号
            result = result.replace(/\\+"/g, '');
            
            // 如果清理后的内容仍有嵌套结构，递归处理
            if (result.includes('[') || result.includes('"') || result.includes("'")) {
                // 检查是否还是JSON格式
                if ((result.startsWith('[') && result.endsWith(']')) || 
                    (result.startsWith('{') && result.endsWith('}'))) {
                    try {
                        // 再次尝试解析JSON
                        return this.cleanNestedBracketsAndQuotes(result);
                    } catch (e) {
                        // 不是有效JSON，继续清理
                    }
                }
                
                // 进一步清理
                return this.cleanStringContent(result);
            }
            
            return result;
        },
        
        // 加载单个商品详情
        async loadGoodsDetail(id) {
            try {
                console.log(`请求商品ID=${id}的详情...`);
                const response = await axios.get(`${API_BASE_URL}/${id}`);
                console.log(`商品ID=${id}的API响应:`, response);
                
                if (response.data.code === '0' && response.data.data) {
                    const goodsData = response.data.data;
                    
                    // 尝试从数据中提取商品信息
                    let goodsInfo = {
                        id: id
                    };
                    
                    // 优先使用后端格式化的数据
                    if (goodsData.formattedData) {
                        const formattedData = goodsData.formattedData;
                        console.log(`使用后端格式化的商品数据:`, formattedData);
                        
                        goodsInfo.name = formattedData.name || '';
                        goodsInfo.description = formattedData.description || '';
                        goodsInfo.price = formattedData.price || '';
                        
                        console.log(`解析出商品信息:`, goodsInfo);
                        
                        // 添加到商品列表
                        if (goodsInfo.name && goodsInfo.description) {
                            console.log(`添加商品到列表:`, goodsInfo);
                            this.goodsList.push(goodsInfo);
                            return;
                        }
                    }
                    
                    // 如果没有格式化数据，尝试从原始responseData中解析
                    if (goodsData.responseData) {
                        try {
                            // 获取原始数据
                            const responseData = goodsData.responseData;
                            console.log(`商品ID=${id}的原始数据:`, responseData);
                            
                            // 检查数据类型
                            let processedData;
                            
                            if (typeof responseData === 'string') {
                                // 处理字符串形式的数据
                                try {
                                    // 尝试解析JSON
                                    processedData = JSON.parse(responseData);
                                } catch (e) {
                                    // 解析失败，尝试解析为CSV格式
                                    const cleanedStr = responseData.replace(/[\[\]"'\\]/g, '');
                                    processedData = cleanedStr.split(',').map(item => item.trim());
                                }
                            } else if (Array.isArray(responseData)) {
                                // 如果已经是数组，直接使用
                                processedData = responseData;
                            } else {
                                console.warn(`商品 ${id} 响应数据格式无法处理:`, responseData);
                                return;
                            }
                            
                            console.log(`处理后的数据:`, processedData);
                            
                            // 确保是数组格式
                            if (Array.isArray(processedData)) {
                                // 至少需要三个元素：名称、描述、价格
                                if (processedData.length >= 3) {
                                    // 深度清理每个字段
                                    const name = this.cleanStringContent(String(processedData[0]));
                                    const description = this.cleanStringContent(String(processedData[1]));
                                    let price = this.cleanStringContent(String(processedData[2]));
                                    
                                    // 处理价格中的特殊符号
                                    price = price.replace(/￥/g, '').trim();
                                    
                                    goodsInfo.name = name;
                                    goodsInfo.description = description;
                                    goodsInfo.price = price;
                                    
                                    console.log(`最终解析商品信息:`, goodsInfo);
                                    
                                    // 只有当所有必要字段都存在时才添加到列表
                                    if (name && description && price) {
                                        console.log(`添加商品到列表:`, goodsInfo);
                                        this.goodsList.push(goodsInfo);
                                    } else {
                                        console.warn(`商品 ${id} 数据不完整，跳过添加`);
                                    }
                                } else {
                                    console.warn(`商品 ${id} 数据元素不足，跳过添加`);
                                }
                            } else {
                                console.warn(`处理后的商品 ${id} 数据不是数组格式，跳过添加`);
                            }
                        } catch (parseError) {
                            console.error(`解析商品 ${id} 详情失败:`, parseError);
                        }
                    } else {
                        console.warn(`商品 ${id} 没有responseData`);
                    }
                } else {
                    console.warn(`获取商品 ${id} 详情失败，或响应码不为0`);
                }
            } catch (error) {
                console.error(`加载商品 ${id} 详情失败:`, error);
            }
        },
        
        // 获取商品总数
        async getTotalGoods() {
            // 直接使用商品列表的长度作为总数
            this.totalGoods = this.goodsList.length;
        },
        
        // 创建商品
        async createGoods() {
            if (!this.validateForm()) return;
            
            try {
                // 直接使用表单数据构建请求对象
                const goodsData = {
                    _id: this.form.id.toString(),
                    _name: this.form.name,
                    _desc: this.form.description,
                    _price: this.form.price.toString()
                };
                
                console.log("创建商品，发送数据:", goodsData);
                const response = await axios.post(`${API_BASE_URL}/create`, goodsData);
                console.log("创建商品API响应:", response);
                
                if (response.data.code === '0') {
                    // 显示交易详情
                    this.showTransactionInfo(response.data.data);
                    
                    console.log("创建商品成功，开始重新加载商品列表...");
                    // 重新加载商品列表
                    this.loadAllGoods();
                    
                    // 重置表单
                    this.resetForm();
                    
                    alert('商品创建成功！');
                } else {
                    alert(`创建失败: ${response.data.message}`);
                }
            } catch (error) {
                console.error('创建商品失败:', error);
                alert('创建商品失败，请查看控制台了解详情');
            }
        },
        
        // 更新商品
        async updateGoods() {
            if (!this.validateForm()) return;
            
            try {
                // 直接使用表单数据构建请求对象
                const goodsData = {
                    _id: this.form.id.toString(),
                    _name: this.form.name,
                    _desc: this.form.description,
                    _price: this.form.price.toString()
                };
                
                console.log("更新商品，发送数据:", goodsData);
                const response = await axios.put(`${API_BASE_URL}/update`, goodsData);
                console.log("更新商品API响应:", response);
                
                if (response.data.code === '0') {
                    // 显示交易详情
                    this.showTransactionInfo(response.data.data);
                    
                    console.log("更新商品成功，开始重新加载商品列表...");
                    // 重新加载商品列表
                    this.loadAllGoods();
                    
                    // 退出编辑模式
                    this.cancelEdit();
                    
                    alert('商品更新成功！');
                } else {
                    alert(`更新失败: ${response.data.message}`);
                }
            } catch (error) {
                console.error('更新商品失败:', error);
                alert('更新商品失败，请查看控制台了解详情');
            }
        },
        
        // 删除商品
        async deleteGoods(id) {
            if (!confirm(`确定要删除ID为 ${id} 的商品吗？`)) return;
            
            try {
                console.log(`删除商品ID=${id}...`);
                const response = await axios.delete(`${API_BASE_URL}/${id}`);
                console.log(`删除商品API响应:`, response);
                
                if (response.data.code === '0') {
                    // 显示交易详情
                    this.showTransactionInfo(response.data.data);
                    
                    console.log("删除商品成功，开始重新加载商品列表...");
                    // 重新加载商品列表
                    this.loadAllGoods();
                    
                    alert('商品删除成功！');
                } else {
                    alert(`删除失败: ${response.data.message}`);
                }
            } catch (error) {
                console.error('删除商品失败:', error);
                alert('删除商品失败，请查看控制台了解详情');
            }
        },
        
        // 编辑商品信息
        prepareUpdateGoods(goods) {
            // 将商品信息填充到表单
            this.form.id = goods.id;
            this.form.name = goods.name;
            this.form.description = goods.description;
            this.form.price = goods.price;
            
            // 修改按钮文本
            this.formTitle = '更新商品';
            this.submitButtonText = '更新';
            this.isUpdate = true;
            
            // 滚动到表单位置
            document.querySelector('#goods-form').scrollIntoView({ behavior: 'smooth' });
        },
        
        // 取消编辑
        cancelEdit() {
            this.editMode = false;
            this.resetForm();
        },
        
        // 重置表单
        resetForm() {
            this.form.id = '';
            this.form.name = '';
            this.form.description = '';
            this.form.price = '';
        },
        
        // 表单验证
        validateForm() {
            // 清理输入值，移除可能存在的方括号和引号
            this.cleanFormInputs();

            if (!this.form.id || isNaN(this.form.id) || this.form.id <= 0) {
                alert('请输入有效的商品ID');
                return false;
            }
            
            // 添加ID范围验证
            const MAX_ID = 1000000;
            if (parseInt(this.form.id) > MAX_ID) {
                alert(`商品ID不能超过${MAX_ID}，这是智能合约的限制`);
                return false;
            }
            
            if (!this.form.name.trim()) {
                alert('请输入商品名称');
                return false;
            }
            
            if (!this.form.description.trim()) {
                alert('请输入商品描述');
                return false;
            }
            
            if (!this.form.price || isNaN(this.form.price) || this.form.price <= 0) {
                alert('请输入有效的商品价格');
                return false;
            }
            
            return true;
        },
        
        // 清理表单输入
        cleanFormInputs() {
            // 清理名称中可能的方括号和引号
            if (this.form.name) {
                this.form.name = this.form.name
                    .replace(/\[|\]|"|'/g, '')
                    .trim();
            }
            
            // 清理描述中可能的方括号和引号
            if (this.form.description) {
                this.form.description = this.form.description
                    .replace(/\[|\]|"|'/g, '')
                    .trim();
            }
            
            // 清理价格中可能的非数字字符
            if (this.form.price) {
                this.form.price = this.form.price
                    .toString()
                    .replace(/[^0-9.]/g, '')
                    .trim();
            }
        },
        
        // 显示交易信息
        showTransactionInfo(info) {
            this.transactionInfo = info;
            this.transactionModal.show();
        },
        
        // 检查区块链连接状态
        async checkBlockchainConnection() {
            this.loading = true;
            
            try {
                console.log("开始检查区块链连接状态...");
                
                // 尝试获取总商品数作为连接测试
                const response = await axios.get(`${API_BASE_URL}/total`);
                console.log("区块链连接测试响应:", response);
                
                if (response.data.code === '0') {
                    const totalGoods = response.data.data;
                    alert(`区块链连接正常，当前共有 ${totalGoods} 个商品记录`);
                } else {
                    alert(`连接测试失败: ${response.data.message || '未知错误'}`);
                }
            } catch (error) {
                console.error('区块链连接测试失败:', error);
                
                let errorMessage = '连接测试失败';
                if (error.response) {
                    errorMessage += `, 状态码: ${error.response.status}`;
                } else if (error.request) {
                    errorMessage += ', 未收到服务器响应，后端服务可能未启动';
                } else {
                    errorMessage += `: ${error.message}`;
                }
                
                alert(errorMessage);
            } finally {
                this.loading = false;
            }
        }
    }
});

// 挂载Vue应用
app.mount('#app'); 